<style></style>

<div id="auto_get_order_list">
    <blockquote class="layui-elem-quote">
       自动获取代练通订单列表
    </blockquote>
    
    <!-- 抽成比例输入区域 -->
    <div class="layui-form-item" style="margin-bottom: 15px;">
        <label class="layui-form-label" style="width: 80px;">抽成比例</label>
        <div class="layui-input-block" style="margin-left: 80px;">
            <div class="layui-input-inline" style="width: 120px;">
                <input type="text" id="commissionRate" name="commissionRate" value="30" placeholder="请输入抽成比例" class="layui-input">
            </div>
            <span class="layui-form-mid">%</span>
        </div>
    </div>
    
    <!-- 保证金增加金额输入区域 -->
    <div class="layui-form-item" style="margin-bottom: 15px;">
        <label class="layui-form-label" style="width: 120px;">保证金增加额</label>
        <div class="layui-input-block" style="margin-left: 120px;">
            <div class="layui-input-inline" style="width: 120px;">
                <input type="number" id="depositIncrease" name="depositIncrease" value="10" placeholder="请输入增加金额" class="layui-input" min="0" step="0.01">
            </div>
            <span class="layui-form-mid layui-word-aux">发单时将与原有保证金相加</span>
        </div>
    </div>
    
    <!-- 代练丸子余额查询区域 -->
    <div class="layui-form-item" style="margin-bottom: 15px;">
        <label class="layui-form-label" style="width: 120px;">代练丸子余额</label>
        <div class="layui-input-block" style="margin-left: 120px;">
            <div class="layui-input-inline" style="width: 120px;">
                <input type="text" id="wanziBalance" name="wanziBalance" placeholder="请点击查询" class="layui-input" readonly>
            </div>
            <button class="layui-btn" id="queryBalanceButton">查询余额</button>
        </div>
    </div>
    
    <!-- 筛选控件 -->
    <div class="layui-form-item" style="margin-bottom: 15px;">
        <label class="layui-form-label" style="width: 120px;">安全金+效率金筛选</label>
        <div class="layui-input-block" style="margin-left: 120px;">
            <div class="layui-input-inline" style="width: 120px;">
                <input type="number" id="depositTotal" name="depositTotal" placeholder="请输入最大总值" class="layui-input" min="0" step="0.01">
            </div>
            <button class="layui-btn layui-btn-primary" id="filterButton">筛选</button>
            <button class="layui-btn layui-btn-warm" id="refreshOrderList">刷新数据</button>
            <button class="layui-btn layui-btn-danger" id="batchPublishButton">批量发单</button>
            <button class="layui-btn layui-btn-normal" id="customOrderBtn">自定义发单</button>
        </div>
    </div>
    
    <!-- 价格区间筛选 -->
    <div class="layui-form-item" style="margin-bottom: 15px;">
        <label class="layui-form-label" style="width: 80px;">价格区间</label>
        <div class="layui-input-block" style="margin-left: 80px;">
            <div class="layui-input-inline" style="width: 120px;">
                <input type="text" id="priceRange" name="priceRange" value="1_20" placeholder="格式：最小值_最大值" class="layui-input">
            </div>
            <span class="layui-form-mid layui-word-aux">格式: 最小值_最大值，如：1_20</span>
        </div>
    </div>

    <!-- 自动化接单功能 -->
    <div class="layui-form-item" style="margin-bottom: 15px;">
        <label class="layui-form-label" style="width: 120px;">自动化接单</label>
        <div class="layui-input-block" style="margin-left: 120px;">
            <button class="layui-btn layui-btn-success" id="startAutoAcceptBtn">启动自动化接单</button>
            <button class="layui-btn layui-btn-danger" id="stopAutoAcceptBtn" disabled>停止自动化接单</button>
            <span class="layui-form-mid layui-word-aux">每10秒检查余额，余额>10元时自动批量发单</span>
        </div>
    </div>
    
   <div class="layui-btn-container" style="display: flex;">
     <!-- 订单存在性检查组件 -->
    {% include '页面/代练通与代练丸子/代练通_判断订单是否存在.html' %}
    
    <!-- 自定义发单表单 -->
    {% include '页面/代练通与代练丸子/自定义发单表单.html' %}
   </div>
    
    <table class="layui-table"
        id="ID-table-demo-init"> </table>
</div>


<!-- 自定义操作模板 -->
<script type="text/html" id="templet-demo-theads-tool">
  <div class="layui-clear-space">
    <a class="layui-btn  layui-btn-sm" lay-event="fadan">发单</a>
  </div>
</script>

<!-- 控制台日志模态框 -->
<div id="consoleModal" style="display: none;">
    <div id="consoleLog" style="max-height: 400px; overflow-y: auto; background-color: #f5f5f5; padding: 10px; font-family: monospace; font-size: 12px;"></div>
    <div style="margin-top: 15px; text-align: center;">
        <button class="layui-btn layui-btn-danger" id="consoleStopButton">停止自动化接单</button>
    </div>
</div>

<!-- 发单确认模态框 -->
<div id="confirmModal" style="display: none; padding: 20px;">
    <div style="margin-bottom: 20px; padding: 10px; background-color: #f2f2f2; border-radius: 5px;">
        <p style="margin: 5px 0;"><strong>原价格：</strong><span id="originalPrice"></span>元</p>
        <p style="margin: 5px 0;"><strong>抽成比例：</strong><span id="commissionRateInfo"></span>%</p>
        <p style="margin: 5px 0;"><strong>抽成收益：</strong><span id="commissionEarning"></span>元</p>
        <p style="margin: 5px 0;"><strong>最终发布价格：</strong><span id="finalPrice"></span>元</p>
        <p style="margin: 5px 0;"><strong>增加的安全保证金：</strong><span id="addedSecurityDeposit"></span>元</p>
        <p style="margin: 5px 0;"><strong>增加的效率保证金：</strong><span id="addedEfficiencyDeposit"></span>元</p>
        <p style="margin: 5px 0;"><strong>订单未完成可额外获得：</strong><span id="potentialExtraIncome"></span>元</p>
    </div>
    
    <form class="layui-form" lay-filter="confirmForm">
        <div class="layui-form-item">
            <label class="layui-form-label">订单金额</label>
            <div class="layui-input-block">
                <input type="text" name="amount" id="amount" lay-verify="required|number" placeholder="请输入订单金额" autocomplete="off" class="layui-input">
            </div>
        </div>
        
        <div class="layui-form-item">
            <label class="layui-form-label">效率保证金</label>
            <div class="layui-input-block">
                <input type="text" name="efficiencyDeposit" id="efficiencyDeposit" lay-verify="required|number" placeholder="请输入效率保证金" autocomplete="off" class="layui-input">
            </div>
        </div>
        
        <div class="layui-form-item">
            <label class="layui-form-label">游戏区服名称</label>
            <div class="layui-input-block">
                <input type="text" name="gameRegionName" id="gameRegionName" placeholder="请输入游戏区服名称" autocomplete="off" class="layui-input">
            </div>
        </div>
        
        <!-- 隐藏字段，存储订单SerialNo -->
        <input type="hidden" name="serialNo" id="serialNo" value="">
        
        <div class="layui-form-item">
            <label class="layui-form-label">时间要求(小时)</label>
            <div class="layui-input-block">
                <input type="text" name="hour" id="hour" lay-verify="required|number" placeholder="请输入时间要求" autocomplete="off" class="layui-input">
            </div>
        </div>
        
        <div class="layui-form-item">
            <label class="layui-form-label">安全保证金</label>
            <div class="layui-input-block">
                <input type="text" name="securityDeposit" id="securityDeposit" lay-verify="required|number" placeholder="请输入安全保证金" autocomplete="off" class="layui-input">
            </div>
        </div>
        
        <div class="layui-form-item">
            <label class="layui-form-label">订单标题</label>
            <div class="layui-input-block">
                <input type="text" name="title" id="title" lay-verify="required" placeholder="请输入订单标题" autocomplete="off" class="layui-input">
            </div>
        </div>
        
        <div class="layui-form-item">
            <div class="layui-input-block">
                <button class="layui-btn" lay-submit lay-filter="submitConfirm">确认发单</button>
                <button type="button" class="layui-btn layui-btn-primary" onclick="closeModal()">取消</button>
            </div>
        </div>
    </form>
</div>

<script>
    var confirmModalIndex = null; // 存储发单确认模态框索引
    
    function closeModal() {
        // 只关闭发单确认模态框，不影响其他模态框
        if (confirmModalIndex) {
            layer.close(confirmModalIndex);
            confirmModalIndex = null;
        }
    }
</script>

<script>
    layui.use(['table', 'layer', 'form'], function () {
        var $ = layui.$;
        var table = layui.table;
        var layer = layui.layer;
        var form = layui.form;
        
        // 当前页码和每页条数
        var currentPage = 1;
        var currentdailiantong_pageSize = 10;
        
        // 存储原始数据（未筛选的数据）
        var originalData = [];
        
        // 存储代练丸子余额
        var wanziBalance = 0;
        
        // 自动化接单相关变量
        var autoAcceptInterval = null; // 定时器
        var isAutoAcceptRunning = false; // 自动化接单是否运行
        var consoleModalIndex = null; // 控制台模态框索引
        
        // 渲染表格
        var orderTable = table.render({
            "elem": "#ID-table-demo-init",
            "title": "自动获取代练通订单列表",
            "cols": [[
                {type: 'checkbox', fixed: 'left'},
                { "field": "SerialNo", "title": "订单ID", "width": 80 },
                { "field": "Title", "title": "标题", "width": 300 },
                { "field": "Price", "title": "价格", "width": 80, "sort": true },
                { "field": "Ensure1", "title": "安全金", "width": 80 },
                { "field": "Ensure2", "title": "效率金", "width": 80 },
                { "field": "TimeLimit", "title": "时间限制", "width": 30, "sort": true },
                { "field": "Create", "title": "创建人", "width": 100 },
                { "field": "Game", "title": "游戏", "width": 100 },
                { "field": "Zone", "title": "区服", "width": 100, "templet": function(d){ return d.Zone && d.Zone.includes('WX') ? d.Zone.replace('WX', '微信') : d.Zone; } },
                { "field": "Server", "title": "服务器", "width": 100 },
                { "field": "Action", "title": "操作", "width": 160, "fixed": "right", "align": "center", "toolbar": "#templet-demo-theads-tool" },
            ]],
            "totalRow": true,
            "data": [], // 初始为空数据
            "page": true, // 使用表格自带的分页
            "limit": currentdailiantong_pageSize,
            "limits": [10, 20, 50], // 可选的每页显示条数
            "cellMinWidth": 80 // 最小单元格宽度
        });
        
        /**
         * 向控制台添加日志
         */
        function appendConsoleLog(message) {
            var now = new Date();
            var timeStr = now.getHours().toString().padStart(2, '0') + ':' + 
                          now.getMinutes().toString().padStart(2, '0') + ':' + 
                          now.getSeconds().toString().padStart(2, '0');
            
            var logItem = '[' + timeStr + '] ' + message;
            
            // 添加到控制台，确保每条日志单独一行
            var consoleElement = $('#consoleLog');
            var logElement = $('<div></div>').text(logItem);
            consoleElement.append(logElement);
            
            // 滚动到底部
            consoleElement.scrollTop(consoleElement[0].scrollHeight);
            
            // 同时输出到浏览器控制台
            console.log(logItem);
        }
        
        /**
         * 启动控制台模态框
         */
        function startConsoleModal() {
            if (consoleModalIndex) {
                // 如果模态框已经存在，先关闭
                layer.close(consoleModalIndex);
            }
            
            // 清空控制台内容
            $('#consoleLog').empty();
            
            // 打开新的模态框
            consoleModalIndex = layer.open({
                type: 1,
                title: '自动化接单控制台日志',
                content: $('#consoleModal'),
                area: ['800px', '500px'],
                btn: [],
                closeBtn: false, // 不显示关闭按钮，只能通过停止按钮关闭
                shadeClose: false // 点击遮罩层不关闭
            });
            
            // 绑定控制台内的停止按钮事件
            $('#consoleStopButton').off('click').on('click', function() {
                stopAutoAcceptOrder();
            });
        }
        
        /**
         * 关闭控制台模态框
         */
        function closeConsoleModal() {
            if (consoleModalIndex) {
                layer.close(consoleModalIndex);
                consoleModalIndex = null;
            }
        }
        
        /**
         * 启动自动化接单功能
         */
        function startAutoAcceptOrder() {
            // 检查是否已经在运行
            if (isAutoAcceptRunning) {
                layer.msg('自动化接单功能已经在运行中', {icon: 3});
                return;
            }
            
            // 启动控制台模态框
            startConsoleModal();
            
            // 更新按钮状态
            $('#startAutoAcceptBtn').attr('disabled', true);
            $('#stopAutoAcceptBtn').attr('disabled', false);
            
            // 设置运行状态
            isAutoAcceptRunning = true;
            
            appendConsoleLog('自动化接单功能已启动');
            appendConsoleLog('系统将每10秒检查一次代练丸子余额');
            appendConsoleLog('当余额大于10元时，将自动获取订单列表并批量发布');
            
            // 立即执行一次检查
            checkBalanceAndAcceptOrders();
            
            // 设置定时器，每10秒检查一次
            autoAcceptInterval = setInterval(function() {
                checkBalanceAndAcceptOrders();
            }, 10000);
        }
        
        /**
         * 停止自动化接单功能
         */
        function stopAutoAcceptOrder() {
            // 检查是否在运行
            if (!isAutoAcceptRunning) {
                layer.msg('自动化接单功能未在运行', {icon: 3});
                return;
            }
            
            // 清除定时器
            clearInterval(autoAcceptInterval);
            autoAcceptInterval = null;
            
            // 更新运行状态
            isAutoAcceptRunning = false;
            
            // 更新按钮状态
            $('#startAutoAcceptBtn').attr('disabled', false);
            $('#stopAutoAcceptBtn').attr('disabled', true);
            
            // 记录日志
            appendConsoleLog('自动化接单功能已停止');
            appendConsoleLog('系统将在1秒后刷新页面以强制终止所有进程');
            
            // 延迟关闭控制台模态框，让用户有时间看到最后的日志
            setTimeout(function() {
                closeConsoleModal();
                // 1秒后自动刷新页面以强制终止所有进程
                setTimeout(function() {
                    location.reload();
                }, 1000);
            }, 2000);
        }
        
        /**
         * 检查余额并执行接单操作
         */
        function checkBalanceAndAcceptOrders() {
            appendConsoleLog('正在检查代练丸子余额...');
            
            // 调用获取余额API
            $.ajax({
                url: '/api/dailianwanzi/get_my_balance/',
                type: 'GET',
                dataType: 'json',
                success: function(res) {
                    if (res.code === 0 && res.data && res.data.balance) {
                        wanziBalance = parseFloat(res.data.balance);
                        $('#wanziBalance').val(wanziBalance.toFixed(2) + ' 元');
                        
                        appendConsoleLog('当前代练丸子余额：' + wanziBalance.toFixed(2) + ' 元');
                        
                        // 检查余额是否大于10元
                        if (wanziBalance > 10) {
                            appendConsoleLog('余额充足，开始自动获取订单列表...');
                            
                            // 直接调用API获取订单数据，不通过表格
                            $.ajax({
                                url: '/api/dailiantong/get_order_list/',
                                type: 'GET',
                                data: {
                                    "page": 1, // 总是从第一页开始
                                    "page_size": 40, // 每次获取40条订单
                                    "price_str": $('#priceRange').val() || ""
                                },
                                dataType: 'json',
                                success: function(orderRes) {
                                    if (orderRes.code === 0 && orderRes.data && orderRes.data.length > 0) {
                                        appendConsoleLog('已获取 ' + orderRes.data.length + ' 条订单，开始批量发单处理...');
                                        
                                        // 直接处理API返回的订单数据
                                        processBatchPublishWithData(orderRes.data);
                                    } else {
                                        appendConsoleLog('当前没有可发布的订单');
                                    }
                                },
                                error: function(xhr, status, error) {
                                    appendConsoleLog('获取订单列表失败：' + error);
                                }
                            });
                        } else {
                            appendConsoleLog('余额不足10元，还需 ' + (10 - wanziBalance).toFixed(2) + ' 元后将自动开始批量发单');
                        }
                    } else {
                        appendConsoleLog('查询余额失败：' + (res.message || '未知错误'));
                    }
                },
                error: function(xhr, status, error) {
                    appendConsoleLog('查询余额网络错误：' + error);
                }
            });
        }
        
        /**
         * 使用API返回的订单数据执行批量发单流程
         */
        function processBatchPublishWithData(orderDataList) {
            // 先检查是否已查询余额
            if (wanziBalance === 0) {
                layer.confirm('尚未查询代练丸子余额，批量发单前必须先查询余额，是否现在查询？', {
                    btn: ['是', '否'],
                    icon: 3,
                    title: '提示'
                }, function(index) {
                    layer.close(index);
                    
                    // 查询余额后，余额获取成功再继续批量发单流程
                    $.when(getWanziBalancePromise()).done(function() {
                        if (wanziBalance > 0) {
                            proceedBatchPublishWithData(orderDataList);
                        } else {
                            layer.msg('余额为0，无法进行批量发单', {icon: 5});
                        }
                    }).fail(function() {
                        layer.msg('余额查询失败，无法进行批量发单', {icon: 5});
                    });
                });
                return;
            }
            
            proceedBatchPublishWithData(orderDataList);
        }
        
        /**
         * 使用API返回的数据继续批量发单流程
         */
        function proceedBatchPublishWithData(orderDataList) {
            if (orderDataList.length === 0) {
                layer.msg('没有可发布的订单', {icon: 5});
                return;
            }

            // 获取抽成比例
            var commissionRate = parseFloat($('#commissionRate').val()) || 0;

            // 验证抽成比例是否有效
            if (isNaN(commissionRate) || commissionRate < 0 || commissionRate > 100) {
                layer.msg('请输入有效的抽成比例（0-100）', {icon: 5});
                return;
            }

            // 计算选中订单的预估总金额和收益
            var estimatedTotalAmount = 0;
            var estimatedTotalCommission = 0;
            var estimatedTotalDepositSum = 0;

            // 检查余额是否足够
            var hasInsufficientBalance = false;
            var invalidOrders = [];

            // 为每个选中的订单计算最终价格并检查余额
            var ordersToProcess = [];
            orderDataList.forEach(function(order) {
                // 获取价格并计算抽成结果
                var price = parseFloat(order.Price) || 0;
                var commissionResult = (price * commissionRate / 100);
                var finalPrice = price - commissionResult;
                
                // 计算安全金与效率金的合计
                var securityDeposit = parseFloat(order.Ensure1 || '0');
                var efficiencyDeposit = parseFloat(order.Ensure2 || '0');
                var depositSum = securityDeposit + efficiencyDeposit;

                // 检查余额是否足够
                if (finalPrice > wanziBalance) {
                    hasInsufficientBalance = true;
                    invalidOrders.push({orderId: order.SerialNo, amount: finalPrice});
                    return;
                }

                // 计算安全金与效率金的合计
                var securityDeposit = parseFloat(order.Ensure1 || '0');
                var efficiencyDeposit = parseFloat(order.Ensure2 || '0');
                
                // 获取用户输入的保证金增加额
                var depositIncrease = parseFloat($('#depositIncrease').val()) || 0;
                
                // 将增加额平均分配给安全保证金和效率保证金
                var addedSecurity = depositIncrease / 2;
                var addedEfficiency = depositIncrease / 2;
                
                // 计算最终的保证金金额
                var finalSecurityDeposit = securityDeposit + addedSecurity;
                var finalEfficiencyDeposit = efficiencyDeposit + addedEfficiency;
                var depositSum = finalSecurityDeposit + finalEfficiencyDeposit;
                
                // 保存处理所需数据
                ordersToProcess.push({
                    originalOrder: order,
                    finalPrice: finalPrice,
                    commissionResult: commissionResult,
                    depositSum: depositSum,
                    securityDeposit: finalSecurityDeposit,
                    efficiencyDeposit: finalEfficiencyDeposit
                });

                estimatedTotalAmount += finalPrice;
                estimatedTotalCommission += commissionResult;
                estimatedTotalDepositSum += depositSum;
            });
            
            // 如果存在余额不足的订单，提示用户
            if (hasInsufficientBalance) {
                var msg = '部分订单余额不足，无法发布：\n';
                invalidOrders.forEach(function(item) {
                    msg += '订单ID：' + item.orderId + '，所需金额：' + item.amount.toFixed(2) + '元\n';
                });
                msg += '\n是否继续发布余额充足的订单？';
                
                // 如果是自动化接单功能在运行，则自动执行确认操作
                if (isAutoAcceptRunning) {
                    appendConsoleLog('自动化接单模式下，自动继续发布余额充足的订单');
                    
                    if (ordersToProcess.length === 0) {
                        appendConsoleLog('所有订单均余额不足，无法进行批量发单');
                        return;
                    }
                    
                    // 显示批量发单确认信息
                    showBatchConfirm(ordersToProcess, estimatedTotalAmount, estimatedTotalCommission);
                } else {
                    layer.confirm(msg, {
                        btn: ['继续发布', '取消'],
                        icon: 3,
                        title: '余额不足提示'
                    }, function(index) {
                        layer.close(index);
                        
                        if (ordersToProcess.length === 0) {
                            layer.msg('所有订单均余额不足，无法进行批量发单', {icon: 5});
                            return;
                        }
                        
                        // 显示批量发单确认信息
                        showBatchConfirm(ordersToProcess, estimatedTotalAmount, estimatedTotalCommission);
                    });
                    return;
                }
            } else {
                // 显示批量发单确认信息
                showBatchConfirm(ordersToProcess, estimatedTotalAmount, estimatedTotalCommission);
            }
        }
        
        /**
         * 以Promise形式加载订单数据
         */
        function loadOrderDataPromise() {
            return new Promise(function(resolve, reject) {
                // 显示加载中
                layer.load();
                
                // 调用订单列表接口
                $.ajax({
                    url: '/api/dailiantong/get_order_list/',
                    type: 'GET',
                    data: {
                        "page": 1, // 总是从第一页开始
                        "page_size": currentdailiantong_pageSize,
                        "price_str": $('#priceRange').val() || ""
                    },
                    dataType: 'json',
                    success: function(res) {
                        if (res.code === 0) {
                            // 处理服务器返回的数据格式
                            var tableData = {
                                "code": 0,
                                "msg": "",
                                "count": res.data && res.data.length ? res.data.length : 0,
                                "data": res.data || []
                            };
                            
                            // 保存原始数据
                            originalData = JSON.parse(JSON.stringify(tableData.data));
                            
                            // 更新表格数据
                            orderTable.reload({
                                data: tableData.data,
                                limit: currentdailiantong_pageSize,
                                page: 1
                            });
                            
                            // 隐藏加载中
                            layer.closeAll('loading');
                            
                            // 解析成功
                            resolve();
                        } else {
                            // 隐藏加载中
                            layer.closeAll('loading');
                            
                            // 解析失败
                            reject();
                        }
                    },
                    error: function(xhr, status, error) {
                        // 隐藏加载中
                        layer.closeAll('loading');
                        
                        // 请求失败
                        reject();
                    }
                });
            });
        }
        
        /**
         * 批量选中表格中的所有数据
         */
        function selectAllOrders() {
            // 清空当前选中状态
            table.checkStatus('ID-table-demo-init').data = [];
            
            // 使用layui的表格API来设置选中状态
            // 先获取表格对象
            var tableObj = table.cache['ID-table-demo-init'] || [];
            
            // 如果表格有数据，遍历所有行并选中
            if (tableObj.length > 0) {
                // 使用setTimeout确保表格已经渲染完成
                setTimeout(function() {
                    // 获取表头的全选复选框并触发点击
                    var headerCheckbox = $('#ID-table-demo-init thead input[type="checkbox"]');
                    if (headerCheckbox && headerCheckbox.length > 0 && !headerCheckbox[0].checked) {
                        headerCheckbox[0].click();
                    }
                }, 500);
            }
        }
        
        /**
         * 加载订单数据函数（兼容分页功能）
         */
        function loadOrderData(page, pageSize) {
            // 显示加载中
            layer.load();
            
            // 调用订单列表接口
            $.ajax({
                url: '/api/dailiantong/get_order_list/',
                type: 'GET',
                data: {
                    "page": page || 1,
                    "page_size": pageSize || currentdailiantong_pageSize,
                    "price_str": $('#priceRange').val() || ""
                },
                dataType: 'json',
                success: function(res) {
                    if (res.code === 0) {
                        // 处理服务器返回的数据格式
                        var tableData = {
                            "code": 0,
                            "msg": "",
                            "count": res.data && res.data.length ? res.data.length : 0,
                            "data": res.data || []
                        };
                        
                        // 保存原始数据
                        originalData = JSON.parse(JSON.stringify(tableData.data));
                        
                        // 更新表格数据
                        orderTable.reload({
                            data: tableData.data,
                            limit: pageSize || currentdailiantong_pageSize,
                            page: page || 1
                        });
                        
                        // 隐藏加载中
                        layer.closeAll('loading');
                    } else {
                        // 隐藏加载中
                        layer.closeAll('loading');
                        layer.msg('获取订单列表失败：' + (res.message || '未知错误'), {icon: 5});
                    }
                },
                error: function(xhr, status, error) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    layer.msg('网络错误，无法获取订单列表', {icon: 5});
                    console.error('获取订单列表失败：', error);
                }
            });
        }
        
        // 初始化时加载数据
        loadOrderData();
        
        /**
         * 获取代练丸子余额
         */
        function getWanziBalance() {
            // 显示加载中
            layer.load();
            
            // 调用获取余额API
            $.ajax({
                url: '/api/dailianwanzi/get_my_balance/',
                type: 'GET',
                dataType: 'json',
                success: function(res) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    
                    if (res.code === 0 && res.data && res.data.balance) {
                        wanziBalance = parseFloat(res.data.balance);
                        $('#wanziBalance').val(wanziBalance.toFixed(2) + ' 元');
                        layer.msg('查询余额成功', {icon: 6});
                    } else {
                        layer.msg('查询余额失败：' + (res.message || '未知错误'), {icon: 5});
                    }
                },
                error: function(xhr, status, error) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    
                    layer.msg('网络错误，无法查询余额', {icon: 5});
                    console.error('查询余额失败：', error);
                }
            });
        }
        
        // 添加查询余额按钮点击事件
        $(document).on('click', '#queryBalanceButton', function() {
            getWanziBalance();
        });
        
        /**
         * 批量发单功能
         */
        $(document).on('click', '#batchPublishButton', function() {
            // 先检查是否已查询余额
            if (wanziBalance === 0) {
                layer.confirm('尚未查询代练丸子余额，批量发单前必须先查询余额，是否现在查询？', {
                    btn: ['是', '否'],
                    icon: 3,
                    title: '提示'
                }, function(index) {
                    layer.close(index);
                    
                    // 查询余额后，余额获取成功再继续批量发单流程
                    $.when(getWanziBalancePromise()).done(function() {
                        if (wanziBalance > 0) {
                            proceedBatchPublish();
                        } else {
                            layer.msg('余额为0，无法进行批量发单', {icon: 5});
                        }
                    }).fail(function() {
                        layer.msg('余额查询失败，无法进行批量发单', {icon: 5});
                    });
                });
                return;
            }
            
            proceedBatchPublish();
        });
        
        /**
         * 以Promise形式获取余额，方便批量发单流程使用
         */
        function getWanziBalancePromise() {
            return new Promise(function(resolve, reject) {
                // 显示加载中
                layer.load();
                
                // 调用获取余额API
                $.ajax({
                    url: '/api/dailianwanzi/get_my_balance/',
                    type: 'GET',
                    dataType: 'json',
                    success: function(res) {
                        // 隐藏加载中
                        layer.closeAll('loading');
                        
                        if (res.code === 0 && res.data && res.data.balance) {
                            wanziBalance = parseFloat(res.data.balance);
                            $('#wanziBalance').val(wanziBalance.toFixed(2) + ' 元');
                            layer.msg('查询余额成功', {icon: 6});
                            resolve();
                        } else {
                            layer.msg('查询余额失败：' + (res.message || '未知错误'), {icon: 5});
                            reject();
                        }
                    },
                    error: function(xhr, status, error) {
                        // 隐藏加载中
                        layer.closeAll('loading');
                        
                        layer.msg('网络错误，无法查询余额', {icon: 5});
                        console.error('查询余额失败：', error);
                        reject();
                    }
                });
            });
        }
        
        /**
         * 继续批量发单流程
         */
        function proceedBatchPublish() {
            // 获取选中的订单
            var checkStatus = table.checkStatus('ID-table-demo-init');
            var selectedOrders = checkStatus.data;

            if (selectedOrders.length === 0) {
                layer.msg('请先选择要批量发布的订单', {icon: 5});
                return;
            }

            // 直接调用新的函数处理选中的订单数据
            proceedBatchPublishWithData(selectedOrders);
        }
        
        /**
         * 显示批量发单确认信息
         */
        function showBatchConfirm(ordersToProcess, totalAmount, totalCommission) {
            // 计算安全金与效率金的合计
            var totalDepositSum = 0;
            ordersToProcess.forEach(function(order) {
                totalDepositSum += order.depositSum;
            });
            
            // 计算用户可获得的总收益（抽成收益+安全金与效率金合计）
            var totalIncome = totalCommission + totalDepositSum;
            
            // 创建确认消息
            var confirmMsg = '确认批量发布 ' + ordersToProcess.length + ' 个订单吗？\n';
            confirmMsg += '\n总发布金额：' + totalAmount.toFixed(2) + ' 元';
            confirmMsg += '\n总抽成收益：' + totalCommission.toFixed(2) + ' 元';
            confirmMsg += '\n安全金与效率金合计：' + totalDepositSum.toFixed(2) + ' 元';
            confirmMsg += '\n预计可获得总收益：' + totalIncome.toFixed(2) + ' 元';
            confirmMsg += '\n\n注意：批量发单过程中请勿关闭页面，系统会自动处理每个订单。';

            // 如果是自动化接单功能在运行，则自动执行确认操作
            if (isAutoAcceptRunning) {
                appendConsoleLog('自动化接单模式下，自动确认批量发布 ' + ordersToProcess.length + ' 个订单');
                
                // 显示加载提示
                var loadingIndex = layer.load(2, {
                    shade: [0.3, '#333']
                });

                // 开始批量处理订单
                processBatchOrders(ordersToProcess, 0, loadingIndex);
            } else {
                // 显示确认框
                layer.confirm(confirmMsg, {
                    btn: ['确认发单', '取消'],
                    icon: 3,
                    title: '批量发单确认'
                }, function(index) {
                    layer.close(index);

                    // 显示加载提示
                    var loadingIndex = layer.load(2, {
                        shade: [0.3, '#333']
                    });

                    // 开始批量处理订单
                    processBatchOrders(ordersToProcess, 0, loadingIndex);
                });
            }
        }
        
        /**
         * 批量处理订单
         */
        function processBatchOrders(ordersToProcess, currentIndex, loadingIndex, successCount = 0, failCount = 0) {
            // 如果是第一次执行，且自动化接单功能在运行，则暂停自动化接单
            if (currentIndex === 0 && isAutoAcceptRunning) {
                appendConsoleLog('开始批量发单，暂停自动化接单功能');
                // 注意：这里只清除定时器，不更新状态标志，以便在完成后恢复
                clearInterval(autoAcceptInterval);
                autoAcceptInterval = null;
            }
            
            // 全部处理完成
            if (currentIndex >= ordersToProcess.length) {
                layer.close(loadingIndex);
                layer.msg('批量发单完成，共成功发布 ' + successCount + ' 个订单，失败 ' + failCount + ' 个订单', {icon: 6});
                
                // 如果是自动化接单功能在运行，并且定时器确实被清除了，则恢复自动化接单
                if (isAutoAcceptRunning && autoAcceptInterval === null) {
                    appendConsoleLog('批量发单完成，恢复自动化接单功能');
                    // 设置新的定时器，继续自动化接单
                    autoAcceptInterval = setInterval(function() {
                        checkBalanceAndAcceptOrders();
                    }, 10000);
                }
                
                // 重新加载表格数据
                loadOrderData();
                return;
            }
            
            var orderData = ordersToProcess[currentIndex];
            var originalOrder = orderData.originalOrder;
            var finalPrice = orderData.finalPrice;
            
            // 检查余额是否足够
            if (finalPrice > wanziBalance) {
                layer.close(loadingIndex);
                layer.msg('余额不足，已停止批量发单，已成功发布 ' + successCount + ' 个订单，失败 ' + (failCount + (ordersToProcess.length - currentIndex)) + ' 个订单', {icon: 5});
                
                // 如果是自动化接单功能在运行，并且定时器确实被清除了，则恢复自动化接单
                if (isAutoAcceptRunning && autoAcceptInterval === null) {
                    appendConsoleLog('批量发单因余额不足停止，恢复自动化接单功能');
                    // 设置新的定时器，继续自动化接单
                    autoAcceptInterval = setInterval(function() {
                        checkBalanceAndAcceptOrders();
                    }, 10000);
                }
                
                // 重新加载表格数据
                loadOrderData();
                return;
            }
            
            // 更新本地余额
            wanziBalance -= finalPrice;
            $('#wanziBalance').val(wanziBalance.toFixed(2) + ' 元');
            
            // 显示当前处理进度
            layer.msg('正在处理第 ' + (currentIndex + 1) + '/' + ordersToProcess.length + ' 个订单', {icon: 1, time: 500});
            
            // 处理单个订单
            processSingleOrderInBatch(originalOrder, function(success) {
                // 生成3-5秒之间的随机延迟时间（毫秒）
                var randomDelay = Math.floor(Math.random() * 2001) + 3000; // 3000-5000ms之间的随机数
                
                if (success) {
                    // 成功则增加成功计数
                    successCount++;
                    
                    // 显示延迟信息
                    layer.msg('当前订单处理完成，等待 ' + (randomDelay/1000).toFixed(1) + ' 秒后处理下一个订单', {icon: 1, time: 1000});
                    appendConsoleLog('第 ' + (currentIndex + 1) + ' 个订单处理成功，等待 ' + (randomDelay/1000).toFixed(1) + ' 秒后处理下一个订单');
                } else {
                    // 失败则增加失败计数，但不弹出提示
                    failCount++;
                    var errorMessage = '第 ' + (currentIndex + 1) + ' 个订单处理失败，自动跳过';
                    console.log(errorMessage);
                    appendConsoleLog(errorMessage, true);
                }
                
                // 处理下一个订单
                setTimeout(function() {
                    processBatchOrders(ordersToProcess, currentIndex + 1, loadingIndex, successCount, failCount);
                }, randomDelay); // 间隔3-5秒处理下一个订单
            });
        }
        
        /**
         * 在批量模式下处理单个订单
         */
        function processSingleOrderInBatch(orderData, callback) {
            // 获取抽成比例
            var commissionRate = parseFloat($('#commissionRate').val()) || 0;
            
            // 获取价格并计算抽成结果
            var price = parseFloat(orderData.Price) || 0;
            var commissionResult = (price * commissionRate / 100).toFixed(2);
            var finalPrice = (price - commissionResult).toFixed(2);
            
            // 计算调整后的安全保证金和效率保证金
            var securityDeposit = parseFloat(orderData.Ensure1 || '0');
            var efficiencyDeposit = parseFloat(orderData.Ensure2 || '0');
            
            // 计算最大允许的保证金和效率金总和（使用最终价格的5倍，与服务器端保持一致）
            var maxAllowedTotalDeposit = parseFloat(finalPrice) * 5;
            var priceMessage = '订单ID：' + orderData.SerialNo + '，原始价格：' + price.toFixed(2) + '元，最终价格：' + finalPrice + '元，最大允许保证金总和：' + maxAllowedTotalDeposit.toFixed(2) + '元';
            console.log(priceMessage);
            appendConsoleLog(priceMessage);
            
            // 计算当前安全金和效率金的总和
                var originalTotalDeposit = securityDeposit + efficiencyDeposit;
                
                // 获取用户输入的保证金增加额
                var depositIncrease = parseFloat($('#depositIncrease').val()) || 0;
                
                // 将用户输入的增加额与原有保证金相加
                var totalDeposit = originalTotalDeposit + depositIncrease;
                
                // 如果总和超过最大允许值，则调整为最大允许值
                if (totalDeposit > maxAllowedTotalDeposit) {
                    var limitMessage = '订单ID：' + orderData.SerialNo + '，目标保证金总和 ' + totalDeposit.toFixed(2) + ' 元 超过最大允许值 ' + maxAllowedTotalDeposit.toFixed(2) + ' 元，已调整为最大允许值';
                    console.log(limitMessage);
                    appendConsoleLog(limitMessage);
                    totalDeposit = maxAllowedTotalDeposit;
                }
            
            // 将金额平均分配给安全金和效率金
            var adjustedSecurityDeposit = (totalDeposit / 2).toFixed(2);
            var adjustedEfficiencyDeposit = (totalDeposit / 2).toFixed(2);
            
            var depositMessage = '订单ID：' + orderData.SerialNo + '，调整后安全保证金：' + adjustedSecurityDeposit + ' 元，调整后效率保证金：' + adjustedEfficiencyDeposit + ' 元';
            console.log(depositMessage);
            appendConsoleLog(depositMessage);
            
            // 最终校验，确保万无一失
            if (parseFloat(adjustedSecurityDeposit) > maxAllowedTotalDeposit) {
                var securityError = '订单ID：' + orderData.SerialNo + '，安全保证金金额 ' + adjustedSecurityDeposit + ' 元 超过最大允许值 ' + maxAllowedTotalDeposit.toFixed(2) + ' 元，禁止发布';
                console.error(securityError);
                appendConsoleLog(securityError, true);
                callback(false);
                return;
            }
            
            if (parseFloat(adjustedEfficiencyDeposit) > maxAllowedTotalDeposit) {
                var efficiencyError = '订单ID：' + orderData.SerialNo + '，效率保证金金额 ' + adjustedEfficiencyDeposit + ' 元 超过最大允许值 ' + maxAllowedTotalDeposit.toFixed(2) + ' 元，禁止发布';
                console.error(efficiencyError);
                appendConsoleLog(efficiencyError, true);
                callback(false);
                return;
            }
            
            // 准备表单数据
            var formData = {
                amount: finalPrice,
                efficiencyDeposit: adjustedEfficiencyDeposit,
                gameRegionName: orderData.Zone || '',
                hour: orderData.TimeLimit || '24',
                securityDeposit: adjustedSecurityDeposit,
                title: orderData.Title || '',
                serialNo: orderData.SerialNo || ''
            };
            
            // 调用发布订单到代练丸子函数，并使用回调函数处理结果
            publishOrderToWanziInBatch(formData, callback);
        }
        
        /**
         * 批量模式下发布订单到代练丸子
         */
        function publishOrderToWanziInBatch(formData, callback) {
            // 调用发布订单API
            $.ajax({
                url: '/api/dailianwanzi/publish_order/',
                type: 'GET',
                data: formData,
                dataType: 'json',
                success: function(res) {
                    if (res.code === 0 && res.data && res.data.tradeNo) {
                        var tradeNo = res.data.tradeNo;
                        var logMessage = '代练丸子发布成功，交易编号：' + tradeNo;
                        console.log(logMessage);
                        appendConsoleLog(logMessage);
                        
                        // 创建主订单
                        $.ajax({
                            url: '/api/order/create/',
                            type: 'POST',
                            contentType: 'application/json',
                            data: JSON.stringify({}),
                            dataType: 'json',
                            success: function(createRes) {
                                if (createRes.code === 0 && createRes.data && createRes.data.order_id) {
                                    var orderId = createRes.data.order_id;
                                    var orderLogMessage = '主订单创建成功，订单ID：' + orderId;
                                    console.log(orderLogMessage);
                                    appendConsoleLog(orderLogMessage);
                                    
                                    // 先设置serialNo、amount和保证金，确保创建子订单时使用正确的编号、价格和保证金
                                    $('#serialNo').val(formData.serialNo || '');
                                    $('#amount').val(formData.amount || '');
                                    $('#securityDeposit').val(formData.securityDeposit || '');
                                    $('#efficiencyDeposit').val(formData.efficiencyDeposit || '');
                                    // 创建代练丸子子订单，订单编号使用服务器返回的tradeNo
                                    // createSubOrderWithName函数内部会自动创建代练通子订单
                                    createSubOrderWithName(orderId, '代练丸子', tradeNo);
                                    
                                    // 回调成功
                                    callback(true);
                                } else {
                                    var errorMessage = '创建订单失败：' + (createRes.message || '未知错误');
                                    console.error(errorMessage);
                                    appendConsoleLog(errorMessage, true);
                                    callback(false);
                                }
                            },
                            error: function(xhr, status, error) {
                                var errorMessage = '创建订单失败：' + error;
                                console.error(errorMessage);
                                appendConsoleLog(errorMessage, true);
                                callback(false);
                            }
                        });
                    } else {
                        var errorMessage = '发布订单到代练丸子失败：' + (res.message || '未知错误');
                        console.error(errorMessage);
                        appendConsoleLog(errorMessage, true);
                        callback(false);
                    }
                },
                error: function(xhr, status, error) {
                    var errorMessage = '发布订单到代练丸子失败：' + error;
                    console.error(errorMessage);
                    appendConsoleLog(errorMessage, true);
                    callback(false);
                }
            });
        }
        
        // 添加表格事件监听
        table.on('tool(ID-table-demo-init)', function(obj) {
            var data = obj.data; // 获得当前行数据
            var layEvent = obj.event; // 获得 lay-event 对应的值
            
            if(layEvent === 'fadan'){
                // 获取抽成比例
                var commissionRate = parseFloat($('#commissionRate').val()) || 0;
                
                // 验证抽成比例是否有效
                if (isNaN(commissionRate) || commissionRate < 0 || commissionRate > 100) {
                    layer.msg('请输入有效的抽成比例（0-100）', {icon: 5});
                    return;
                }
                
                // 打印当前行数据到控制台，同时将Zone字段中的WX替换为微信
                var displayData = JSON.parse(JSON.stringify(data)); // 深拷贝数据对象
                if (displayData.Zone && displayData.Zone.includes('WX')) {
                    displayData.Zone = displayData.Zone.replace('WX', '微信');
                }
                
                // 获取价格并计算抽成结果
                var price = parseFloat(data.Price) || 0;
                var commissionResult = (price * commissionRate / 100).toFixed(2);
                displayData.CommissionResult = commissionResult;
                displayData.Price = displayData.Price - commissionResult;
                
                // 设置模态框数据
                $('#originalPrice').text(price.toFixed(2));
                $('#commissionRateInfo').text(commissionRate);
                $('#commissionEarning').text(commissionResult);
                $('#finalPrice').text(displayData.Price.toFixed(2));
                
                // 计算调整后的安全保证金和效率保证金
                var securityDeposit = parseFloat(displayData.Ensure1 || '0');
                var efficiencyDeposit = parseFloat(displayData.Ensure2 || '0');
                
                    // 获取用户输入的保证金增加额
                var depositIncrease = parseFloat($('#depositIncrease').val()) || 0;
                
                // 将增加额平均分配给安全保证金和效率保证金
                var addedSecurity = depositIncrease / 2;
                var addedEfficiency = depositIncrease / 2;
                
                // 在原有金额基础上增加随机金额
                var adjustedSecurityDeposit = securityDeposit + addedSecurity;
                var adjustedEfficiencyDeposit = efficiencyDeposit + addedEfficiency;
                
                // 计算订单未完成时可额外获得的总收入
                var potentialExtraIncome = (addedSecurity + addedEfficiency).toFixed(2);
                
                // 填充表单字段
                $('#amount').val(displayData.Price.toFixed(2));
                $('#efficiencyDeposit').val(adjustedEfficiencyDeposit.toFixed(2));
                $('#gameRegionName').val(displayData.Zone || '');
                $('#hour').val(displayData.TimeLimit || '24');
                $('#securityDeposit').val(adjustedSecurityDeposit.toFixed(2));
                $('#title').val(displayData.Title || '');
                // 存储SerialNo到隐藏字段，用于创建子订单
                $('#serialNo').val(displayData.SerialNo || '');
                
                // 设置增加金额的显示
                $('#addedSecurityDeposit').text(addedSecurity.toFixed(2));
                $('#addedEfficiencyDeposit').text(addedEfficiency.toFixed(2));
                $('#potentialExtraIncome').text(potentialExtraIncome);
                
                console.log('当前订单数据:', displayData);
                
                // 打开模态框，并保存索引
                confirmModalIndex = layer.open({
                    type: 1,
                    title: '确认发单 - 订单ID: ' + data.SerialNo,
                    content: $('#confirmModal'),
                    area: ['500px', 'auto'],
                    success: function() {
                        // 重新渲染表单
                        layui.form.render();
                    },
                    end: function() {
                        // 隐藏模态框
                        $('#confirmModal').hide();
                        // 重置索引
                        confirmModalIndex = null;
                    }
                });
            }
        });
        
        // 创建主订单函数 - 挂载到window对象以便在订单整合功能中调用
        window.createMainOrder = function() {
            // 显示加载中
            layer.load();
            
            var logMessage = '开始创建主订单...';
            console.log(logMessage);
            appendConsoleLog(logMessage);
            
            // 调用创建订单接口
            $.ajax({
                url: '/api/order/create/',
                type: 'POST',
                contentType: 'application/json',
                data: JSON.stringify({}),
                dataType: 'json',
                success: function(res) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    
                    if (res.code === 0 && res.data && res.data.order_id) {
                        var successMessage = '主订单创建成功，订单ID：' + res.data.order_id;
                        console.log(successMessage);
                        appendConsoleLog(successMessage);
                        return res.data.order_id;
                    } else {
                        var errorMessage = '创建订单失败：' + (res.message || '未知错误');
                        layer.msg(errorMessage, {icon: 5});
                        console.error(errorMessage);
                        appendConsoleLog(errorMessage, true);
                        return null;
                    }
                },
                error: function(xhr, status, error) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    
                    var errorMessage = '网络错误，无法创建订单：' + error;
                    layer.msg(errorMessage, {icon: 5});
                    console.error(errorMessage);
                    appendConsoleLog(errorMessage, true);
                    return null;
                }
            });
        };
        
        // 创建子订单函数 - 挂载到window对象以便在订单整合功能中调用
        window.createSubOrder = function(orderId, subOrderName, subOrderNo) {
            // 显示加载中
            layer.load();
            
            // 准备请求数据
            var requestData = {
                order_id: orderId,
                sub_order_name: subOrderName,
                sub_order_no: subOrderNo
            };
            
            // 调用创建子订单API
            return $.ajax({
                url: '/api/order/sub/create/',
                type: 'POST',
                data: requestData,
                dataType: 'json',
                success: function(res) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    
                    if (res.code === 0 && res.data && res.data.sub_order_id) {
                        layer.msg('子订单创建成功，子订单ID：' + res.data.sub_order_id, {icon: 6});
                        return res.data.sub_order_id;
                    } else {
                        layer.msg('创建子订单失败：' + (res.message || '未知错误'), {icon: 5});
                        return null;
                    }
                },
                error: function(xhr, status, error) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    
                    layer.msg('网络错误，无法创建子订单', {icon: 5});
                    console.error('创建子订单失败：', error);
                    return null;
                }
            });
        };
        
        // 发布订单到代练丸子函数
        function publishOrderToWanzi(formData) {
            // 显示加载中
            layer.load();
            
            var logMessage = '开始发布订单到代练丸子...';
            console.log(logMessage);
            appendConsoleLog(logMessage);
            
            // 调用发布订单API
            $.ajax({
                url: '/api/dailianwanzi/publish_order/',
                type: 'GET',
                data: formData,
                dataType: 'json',
                success: function(res) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    
                    if (res.code === 0 && res.data && res.data.tradeNo) {
                        var tradeNo = res.data.tradeNo;
                        var successMessage = '代练丸子发布成功，交易编号：' + tradeNo;
                        console.log(successMessage);
                        appendConsoleLog(successMessage);
                        
                        // 创建主订单
                        $.ajax({
                            url: '/api/order/create/',
                            type: 'POST',
                            contentType: 'application/json',
                            data: JSON.stringify({}),
                            dataType: 'json',
                            success: function(createRes) {
                                if (createRes.code === 0 && createRes.data && createRes.data.order_id) {
                                    var orderId = createRes.data.order_id;
                                    var orderMessage = '主订单创建成功，订单ID：' + orderId;
                                    console.log(orderMessage);
                                    appendConsoleLog(orderMessage);
                                    
                                    // 设置表单字段值，确保创建子订单时使用正确的信息
                                    $('#serialNo').val(formData.serialNo || '');
                                    $('#amount').val(formData.amount || '');
                                    $('#securityDeposit').val(formData.securityDeposit || '');
                                    $('#efficiencyDeposit').val(formData.efficiencyDeposit || '');
                                    
                                    // 创建代练丸子子订单，订单编号使用服务器返回的tradeNo
                                    createSubOrderWithName(orderId, '代练丸子', tradeNo);
                                } else {
                                    var errorMessage = '创建订单失败：' + (createRes.message || '未知错误');
                                    layer.msg(errorMessage, {icon: 5});
                                    console.error(errorMessage);
                                    appendConsoleLog(errorMessage, true);
                                }
                            },
                            error: function(xhr, status, error) {
                                var errorMessage = '网络错误，无法创建订单：' + error;
                                layer.msg(errorMessage, {icon: 5});
                                console.error(errorMessage);
                                appendConsoleLog(errorMessage, true);
                            }
                        });
                    } else {
                        var errorMessage = '发布订单到代练丸子失败：' + (res.message || '未知错误');
                        layer.msg(errorMessage, {icon: 5});
                        console.error(errorMessage);
                        appendConsoleLog(errorMessage, true);
                    }
                },
                error: function(xhr, status, error) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    
                    var errorMessage = '网络错误，无法发布订单到代练丸子：' + error;
                    layer.msg(errorMessage, {icon: 5});
                    console.error(errorMessage);
                    appendConsoleLog(errorMessage, true);
                }
            });
        }
        
        // 创建指定名称的子订单函数
        function createSubOrderWithName(orderId, subOrderName, subOrderNo) {
            // 添加判断：如果是代练通子订单且order_id等于sub_order_no，则不发送请求
            if (subOrderName === '代练通' && orderId === subOrderNo) {
                console.log('代练通子订单已存在或参数异常，取消创建请求');
                layer.closeAll('loading');
                return;
            }
            
            // 显示加载中
            layer.load();
            
            // 准备请求数据
            var requestData = {
                order_id: orderId,
                sub_order_name: subOrderName,
                sub_order_no: subOrderNo
            };
            
            // 根据来源添加对应的价格信息和保证金信息
            if (subOrderName === '代练通') {
                // 如果来源为代练通，则使用订单的原始价格和原始保证金
                var originalOrder = originalData.find(function(item) {
                    return item.SerialNo === subOrderNo;
                });
                if (originalOrder) {
                    requestData.price = parseFloat(originalOrder.Price) || 0;
                    // 计算保证金总和：安全保证金 + 效率保证金
                    var securityDeposit = parseFloat(originalOrder.Ensure1) || 0;
                    var efficiencyDeposit = parseFloat(originalOrder.Ensure2) || 0;
                    requestData.margin = (securityDeposit + efficiencyDeposit).toFixed(2);
                }
            } else if (subOrderName === '代练丸子') {
                // 如果来源为代练丸子，则使用更新后的价格和保证金
                var amount = parseFloat($('#amount').val()) || 0;
                requestData.price = amount;
                // 计算保证金总和：安全保证金 + 效率保证金
                var securityDeposit = parseFloat($('#securityDeposit').val()) || 0;
                var efficiencyDeposit = parseFloat($('#efficiencyDeposit').val()) || 0;
                requestData.margin = (securityDeposit + efficiencyDeposit).toFixed(2);
            }
            
            // 调用创建子订单API
            $.ajax({
                url: '/api/order/sub/create/',
                type: 'POST',
                data: requestData,
                dataType: 'json',
                success: function(subCreateRes) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    
                    if (subCreateRes.code === 0 && subCreateRes.data && subCreateRes.data.sub_order_id) {
                        var successMessage = subOrderName + '子订单创建成功，子订单ID：' + subCreateRes.data.sub_order_id;
                        console.log(successMessage);
                        appendConsoleLog(successMessage);
                        
                        // 如果创建的是代练丸子子订单，则继续创建代练通子订单
                        if (subOrderName === '代练丸子') {
                            // 获取存储的SerialNo
                            var serialNo = $('#serialNo').val();
                            // 使用SerialNo作为代练通子订单的编号，如果没有则使用orderId作为备份
                            createSubOrderWithName(orderId, '代练通', serialNo || orderId);
                        } 
                        // 如果创建的是代练通子订单，则表示两个子订单都创建完成
                        else if (subOrderName === '代练通') {
                            // 获取存储的SerialNo
                            var serialNo = $('#serialNo').val();
                            
                            var completeMessage = '发单完成！订单ID：' + orderId + '，代练通订单编号：' + serialNo;
                            console.log(completeMessage);
                            appendConsoleLog(completeMessage);
                            
                            // 从原始数据中移除已发布的订单
                            originalData = originalData.filter(function(item) {
                                return item.SerialNo !== serialNo;
                            });
                            
                            // 重新加载表格数据，不包含已发布的订单
                            orderTable.reload({
                                data: originalData,
                                limit: currentdailiantong_pageSize,
                                page: 1 // 重置到第一页
                            });
                            
                            layer.msg('发单成功！订单ID：' + orderId, {icon: 6}, function() {
                                // 只关闭发单确认模态框，不影响其他模态框
                                if (confirmModalIndex) {
                                    layer.close(confirmModalIndex);
                                    confirmModalIndex = null;
                                }
                            });
                        }
                    } else {
                        var errorMessage = '创建' + subOrderName + '子订单失败：' + (subCreateRes.message || '未知错误');
                        layer.msg(errorMessage, {icon: 5});
                        console.error(errorMessage);
                        appendConsoleLog(errorMessage, true);
                    }
                },
                error: function(xhr, status, error) {
                    // 隐藏加载中
                    layer.closeAll('loading');
                    
                    var errorMessage = '网络错误，无法创建' + subOrderName + '子订单：' + error;
                    layer.msg(errorMessage, {icon: 5});
                    console.error(errorMessage);
                    appendConsoleLog(errorMessage, true);
                }
            });
        }
        
        // 每页条数改变事件
        form.on('select(dailiantong_pageSize)', function(data) {
            var newdailiantong_pageSize = parseInt(data.value);
            // 重新加载数据，应用新的分页大小
            loadOrderData(1, newdailiantong_pageSize);
        });
        
        // 监听表格分页事件，确保分页控件正常响应
        table.on('page(ID-table-demo-init)', function(obj) {
            currentPage = obj.curr;
            // 重新加载数据，应用新的页码
            loadOrderData(currentPage, currentdailiantong_pageSize);
        });
        
        /**
         * 根据安全金和效率金总和进行筛选
         */
        function filterOrderData() {
            // 获取筛选总值
            var depositTotal = parseFloat($('#depositTotal').val());
            
            // 验证输入
            if (isNaN(depositTotal) || depositTotal < 0) {
                layer.msg('请输入有效的最大总值（大于等于0的数字）', {icon: 5});
                return;
            }
            
            // 从原始数据中筛选
            var filteredData = originalData.filter(function(item) {
                // 计算安全金和效率金的总和
                var ensure1 = parseFloat(item.Ensure1) || 0;
                var ensure2 = parseFloat(item.Ensure2) || 0;
                var total = ensure1 + ensure2;
                
                // 返回总和不超过筛选值的数据
                return total <= depositTotal;
            });
            
            // 更新表格数据
            orderTable.reload({
                data: filteredData,
                limit: currentdailiantong_pageSize,
                page: 1 // 重置到第一页
            });
            
            layer.msg('筛选完成，共找到 ' + filteredData.length + ' 条符合条件的记录', {icon: 6});
        }
        
        // 添加刷新按钮功能
        $(document).on('click', '#refreshOrderList', function() {
            // 清除筛选框内容
            $('#depositTotal').val('');
            loadOrderData(currentPage, currentdailiantong_pageSize);
        });
        
        // 添加筛选按钮点击事件
        $(document).on('click', '#filterButton', function() {
            filterOrderData();
        });
        
        // 添加回车键触发筛选
        $(document).on('keypress', '#depositTotal', function(e) {
            if (e.which === 13) { // 回车键
                filterOrderData();
            }
        });
        
        // 表单提交处理
        layui.form.on('submit(submitConfirm)', function(data) {
            // 表单数据
            var formData = data.field;
            console.log('表单提交数据:', formData);
            
            // 获取订单金额、保证金和效率金
            var orderAmount = parseFloat(formData.amount) || 0;
            var securityDeposit = parseFloat(formData.securityDeposit) || 0;
            var efficiencyDeposit = parseFloat(formData.efficiencyDeposit) || 0;
            
            // 校验保证金金额是否超过订单价格的5倍
            if (securityDeposit > orderAmount * 5) {
                layer.msg('保证金金额 ' + securityDeposit.toFixed(2) + ' 元 超过订单价格 ' + orderAmount.toFixed(2) + ' 元 的5倍，禁止发布', {icon: 5});
                return false; // 阻止表单跳转
            }
            
            // 校验效率金金额是否超过订单价格的5倍
            if (efficiencyDeposit > orderAmount * 5) {
                layer.msg('效率金金额 ' + efficiencyDeposit.toFixed(2) + ' 元 超过订单价格 ' + orderAmount.toFixed(2) + ' 元 的5倍，禁止发布', {icon: 5});
                return false; // 阻止表单跳转
            }
            
            // 如果余额为0，提示用户先查询余额
            if (wanziBalance === 0) {
                layer.confirm('尚未查询代练丸子余额，是否先查询余额？', {
                    btn: ['是', '否'],
                    icon: 3,
                    title: '提示'
                }, function(index) {
                    layer.close(index);
                    getWanziBalance();
                }, function() {
                    // 用户选择不查询余额，继续发单流程
                    publishOrderToWanzi(formData);
                });
                return false; // 阻止表单跳转
            }
            
            // 检查订单金额是否超出余额
            if (orderAmount > wanziBalance) {
                layer.msg('订单金额 ' + orderAmount.toFixed(2) + ' 元 超出代练丸子余额 ' + wanziBalance.toFixed(2) + ' 元，禁止发布', {icon: 5});
                return false; // 阻止表单跳转
            }
            
            // 调用发布订单到代练丸子函数
            publishOrderToWanzi(formData);
            
            return false; // 阻止表单跳转
        });
        
        // 添加自动化接单启动按钮点击事件
        $(document).on('click', '#startAutoAcceptBtn', function() {
            startAutoAcceptOrder();
        });
        
        // 添加自动化接单停止按钮点击事件
        $(document).on('click', '#stopAutoAcceptBtn', function() {
            stopAutoAcceptOrder();
        });
    });
</script>